package com.example.d3_collection_list;

import java.util.ArrayList;

/**
 * ArrayList的源码分析
 */
@SuppressWarnings({"all"})
public class ArrayListSource {
    public static void main(String[] args) {
        /*
        ArrayList的特点
        查询速度快(注意：是根据索引查询数据快)：查询数据通过地址值和索引定位,查询任意数据耗时相同
        删除效率低：可能要把后面很多的数据进行前移
        添加效率低：可能要把后面的数据向后移动,在添加元素,也有可能要对数组进行扩容
        原理：
        1.利用无参构造器创建的集合,会在底层默认创建一个默认长度为0的数组
        2.添加第一个元素的时候,底层会创建一个长度为10的数组
        3.当数组存满是,会扩容1.5倍
        4.如果一次添加多个元素,并且1.5倍还放不下,则新创建的数组以实际长度为标准
         */
        // 注意Idea 默认情况下,Debug 显示的数据是简化后的,如果希望看到完整的数据
        // 需要做设置.
        // 使用无参构造器创建ArrayList对象
        ArrayList list = new ArrayList();
        // ArrayList list = new ArrayList(8);
        // 使用for给list集合添加 1-10数据
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        // 使用for给list集合添加 11-15数据
        for (int i = 11; i <= 15; i++) {
            list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);


        /*
        // 第一步
        先调用ArrayList的无参构造器,去创建一个空数组
            public ArrayList() {
                this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
            }

        // 第二步
        调用add方法
        1.先确定是否要扩容
        ensureCapacityInternal(size + 1);这个方法就是判断是否要进行扩容,
        2.然后进行赋值

            public boolean add(E e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }

        // 第三步
        指向ensureCapacityInternal方法,进入方法后先进行判断,
        private void ensureCapacityInternal(int minCapacity) {
            // 我们第一次进行扩容的时候,此时elementData是null,因此会进入if语句
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                 DEFAULT_CAPACITY这是一个默认值,是10 minCapacity 是1
                 因此Nath.max方法会在两个数中选出一个最大值赋值给minCapactiy 所以此时minCapacity就是10
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }

            ensureExplicitCapacity(minCapacity);
        }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++; // 用来记录集合被修改的次数,主要是防止同时有多个线程去修改,如果有那么会抛出一个异常

        // overflow-conscious code
        minCapacity是我需要的最小容量
        elementData.length
        也就是说,我们需要10个的大小,但是你这个数组能给我提供的只有0 两数相减的结果去过大于0,说明就需要扩容了
        if (minCapacity - elementData.length > 0)
            // 如果满足上面if的条件,那么就真的扩容
            grow(minCapacity);//真正的扩容的方法
    }


    // 真的扩容的方法
    private void grow(int minCapacity) {
        // overflow-conscious code
        第一次进行扩容的时候,因为数组是空 ,所以elementData.length就是0 所以把0赋值给了oldCapacity
        int oldCapacity = elementData.length;
        然后oldCapacity>>1 也就是把oldCapacity除2 但是因为oldCapacity是0 所以结果还是0 因此oldCapacity+（oldCapacity>>1）的结果还是0.把这个结果赋给newCapacity也是0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        然后newCapacity - minCapacity  因为minCapacity是10 所以0-10小于0
        if (newCapacity - minCapacity < 0)
            然后就进入if语句 把 minCapacity 赋值给newCapacity 所以newCapacity的结果就是10 这也就是为什么,第一次扩容的时候 是10 第二次就按照1.5倍进行扩容
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        这里就是进行数组的拷贝
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

         */
    }
}